77 research outputs found
Rendezvous in Networks in Spite of Delay Faults
Two mobile agents, starting from different nodes of an unknown network, have
to meet at the same node. Agents move in synchronous rounds using a
deterministic algorithm. Each agent has a different label, which it can use in
the execution of the algorithm, but it does not know the label of the other
agent. Agents do not know any bound on the size of the network. In each round
an agent decides if it remains idle or if it wants to move to one of the
adjacent nodes. Agents are subject to delay faults: if an agent incurs a fault
in a given round, it remains in the current node, regardless of its decision.
If it planned to move and the fault happened, the agent is aware of it. We
consider three scenarios of fault distribution: random (independently in each
round and for each agent with constant probability 0 < p < 1), unbounded adver-
sarial (the adversary can delay an agent for an arbitrary finite number of
consecutive rounds) and bounded adversarial (the adversary can delay an agent
for at most c consecutive rounds, where c is unknown to the agents). The
quality measure of a rendezvous algorithm is its cost, which is the total
number of edge traversals. For random faults, we show an algorithm with cost
polynomial in the size n of the network and polylogarithmic in the larger label
L, which achieves rendezvous with very high probability in arbitrary networks.
By contrast, for unbounded adversarial faults we show that rendezvous is not
feasible, even in the class of rings. Under this scenario we give a rendezvous
algorithm with cost O(nl), where l is the smaller label, working in arbitrary
trees, and we show that \Omega(l) is the lower bound on rendezvous cost, even
for the two-node tree. For bounded adversarial faults, we give a rendezvous
algorithm working for arbitrary networks, with cost polynomial in n, and
logarithmic in the bound c and in the larger label L
Deterministic Rendezvous at a Node of Agents with Arbitrary Velocities
We consider the task of rendezvous in networks modeled as undirected graphs.
Two mobile agents with different labels, starting at different nodes of an
anonymous graph, have to meet. This task has been considered in the literature
under two alternative scenarios: weak and strong. Under the weak scenario,
agents may meet either at a node or inside an edge. Under the strong scenario,
they have to meet at a node, and they do not even notice meetings inside an
edge. Rendezvous algorithms under the strong scenario are known for synchronous
agents. For asynchronous agents, rendezvous under the strong scenario is
impossible even in the two-node graph, and hence only algorithms under the weak
scenario were constructed. In this paper we show that rendezvous under the
strong scenario is possible for agents with restricted asynchrony: agents have
the same measure of time but the adversary can arbitrarily impose the speed of
traversing each edge by each of the agents. We construct a deterministic
rendezvous algorithm for such agents, working in time polynomial in the size of
the graph, in the length of the smaller label, and in the largest edge
traversal time.Comment: arXiv admin note: text overlap with arXiv:1704.0888
Asynchronous approach in the plane: A deterministic polynomial algorithm
In this paper we study the task of approach of two mobile agents having the
same limited range of vision and moving asynchronously in the plane. This task
consists in getting them in finite time within each other's range of vision.
The agents execute the same deterministic algorithm and are assumed to have a
compass showing the cardinal directions as well as a unit measure. On the other
hand, they do not share any global coordinates system (like GPS), cannot
communicate and have distinct labels. Each agent knows its label but does not
know the label of the other agent or the initial position of the other agent
relative to its own. The route of an agent is a sequence of segments that are
subsequently traversed in order to achieve approach. For each agent, the
computation of its route depends only on its algorithm and its label. An
adversary chooses the initial positions of both agents in the plane and
controls the way each of them moves along every segment of the routes, in
particular by arbitrarily varying the speeds of the agents. A deterministic
approach algorithm is a deterministic algorithm that always allows two agents
with any distinct labels to solve the task of approach regardless of the
choices and the behavior of the adversary. The cost of a complete execution of
an approach algorithm is the length of both parts of route travelled by the
agents until approach is completed. Let and be the initial
distance separating the agents and the length of the shortest label,
respectively. Assuming that and are unknown to both agents, does
there exist a deterministic approach algorithm always working at a cost that is
polynomial in and ? In this paper, we provide a positive answer to
the above question by designing such an algorithm
Byzantine Gathering in Polynomial Time
We study the task of Byzantine gathering in a network modeled as a graph.
Despite the presence of Byzantine agents, all the other (good) agents, starting
from possibly different nodes and applying the same deterministic algorithm,
have to meet at the same node in finite time and stop moving. An adversary
chooses the initial nodes of the agents and assigns a different label to each
of them. The agents move in synchronous rounds and communicate with each other
only when located at the same node. Within the team, f of the agents are
Byzantine. A Byzantine agent acts in an unpredictable way: in particular it may
forge the label of another agent or create a completely new one. Besides its
label, which corresponds to a local knowledge, an agent is assigned some global
knowledge GK that is common to all agents. In literature, the Byzantine
gathering problem has been analyzed in arbitrary n-node graphs by considering
the scenario when GK=(n,f) and the scenario when GK=f. In the first (resp.
second) scenario, it has been shown that the minimum number of good agents
guaranteeing deterministic gathering of all of them is f+1 (resp. f+2). For
both these scenarios, all the existing deterministic algorithms, whether or not
they are optimal in terms of required number of good agents, have a time
complexity that is exponential in n and L, where L is the largest label
belonging to a good agent.
In this paper, we seek to design a deterministic solution for Byzantine
gathering that makes a concession on the proportion of Byzantine agents within
the team, but that offers a significantly lower complexity. We also seek to use
a global knowledge whose the length of the binary representation is small.
Assuming that the agents are in a strong team i.e., a team in which the number
of good agents is at least some prescribed value that is quadratic in f, we
give positive and negative results
Almost-Optimal Deterministic Treasure Hunt in Arbitrary Graphs
A mobile agent navigating along edges of a simple connected graph, either
finite or countably infinite, has to find an inert target (treasure) hidden in
one of the nodes. This task is known as treasure hunt. The agent has no a
priori knowledge of the graph, of the location of the treasure or of the
initial distance to it. The cost of a treasure hunt algorithm is the worst-case
number of edge traversals performed by the agent until finding the treasure.
Awerbuch, Betke, Rivest and Singh [3] considered graph exploration and treasure
hunt for finite graphs in a restricted model where the agent has a fuel tank
that can be replenished only at the starting node . The size of the tank is
, for some positive real constant , where , called
the radius of the graph, is the maximum distance from to any other node.
The tank of size allows the agent to make at most edge
traversals between two consecutive visits at node .
Let be the number of edges whose at least one extremity is at distance
less than from . Awerbuch, Betke, Rivest and Singh [3] conjectured that
it is impossible to find a treasure hidden in a node at distance at most at
cost nearly linear in . We first design a deterministic treasure hunt
algorithm working in the model without any restrictions on the moves of the
agent at cost , and then show how to modify this
algorithm to work in the model from [3] with the same complexity. Thus we
refute the above twenty-year-old conjecture. We observe that no treasure hunt
algorithm can beat cost for all graphs and thus our algorithms
are also almost optimal
- …